﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;

namespace Asol.Reporting.Support.Pics
{
    /// <summary>
    /// Knihovna ikon 16x16px
    /// </summary>
    public class IconLibrary16
    {
        #region Image DialogApply
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku dialog-apply.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu DialogApply_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property DialogApply, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property DialogApply_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\LCS\Tools\GreenSchedule4\FrxEditor\Pics\16\dialog-apply.png
        /// </remarks>
        public static System.Drawing.Image DialogApply_Cached
        {
            get
            {
                if (_DialogApply == null) _DialogApply = DialogApply;
                return _DialogApply;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku dialog-apply.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image DialogApply_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití DialogApply_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property DialogApply_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\LCS\Tools\GreenSchedule4\FrxEditor\Pics\16\dialog-apply.png
        /// </remarks>
        public static System.Drawing.Image DialogApply { get { return _ImageCreateFrom(_DialogApply_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru dialog-apply.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití DialogApply_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property DialogApply_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\LCS\Tools\GreenSchedule4\FrxEditor\Pics\16\dialog-apply.png
        /// </remarks>
        public static System.Drawing.Image DialogApply_FromFile { get { return _ImageCreateFrom(_DialogApply_string, "dialog-apply.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru DialogApply
        /// </summary>
        /// <returns></returns>
        private static string _DialogApply_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1364);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAA3XAAAN1wFCKJt4AAAACXZwQWcAAAAQAAAAEABcxq3DAAAC");
            sb.Append("ZklEQVQ4y5WTX0gUURTGvzv3zurutv5rNWhDRUJNAycQMgMNtyhJCqIQ+kcPgYFIQg9tUb0l8xpB5EsRPRlRiYFWTFRaQkXmSpqpIZW2bWrbTrvrzNy704tGmKGe58Pv");
            sb.Append("nPOd7yO2bWO55Q94NsmMdRJCRkzLatRUPUhWAqg9n/XmyK4GhQsT957emk2YMVVawfQ967LzC4tzS0mBL4+cPHDOCYITywL4Ax4qM3Z5X/VBd1gfgkxT0TPwyEiK5M1l");
            sb.Append("AQghx0vyy7zZmV4I24JhJNHdr5lciItLAvwBj5tRqtZV7ndN/ggi212Ejhe3E1yIC5qqR5cEUEk6XV5cmcpkAdsmCM+EERx7HbVt+woAsPnGHWfT6xmll2zbvmtx3qSp");
            sb.Append("OvcHPDkOJp+qKqtJnZgOwpep4EbXtTjnollTdRMApLk1FQdLuX6stmHNhryNR2XGev0BTw6jtKWidCszrGlQ4sToxDAmvo9/AtA2P1gCAJmxtt1b6pyybMFfXuOqUrYp");
            sb.Append("jLF3lLJDZesVRzg6BpfsRWfv/YTFeaOm6n/MM3/C6Icv7/NyMitTQvowCtb6WMaqvas5N5L67FfIkhsDH98m9UTklabqj//WSAIAi/P6ofHB7vae9jiTPIjEQnDIJvFm");
            sb.Append("ZNFILARiO9ATfG5YXDQtFFkCAE3Vf3Ehdn6bCV+986QjbhqAaRmYnBqETJzoG+m3uLA6NFUP/uORhVnYfibtMKVSa0WJ4vKmp8PiNh68fJbgQhRpqv55ScDcVzZTSeos");
            sb.Append("zM1Ni8biVmh6qvVhy8/mRV36vzT6Ax4fpVIXAZJcJKs1VY8s1vcbnWoQKAwBvI4AAAAldEVYdGRhdGU6Y3JlYXRlADIwMTAtMDEtMTFUMDk6MTI6NDQtMDc6MDD9MHEd");
            sb.Append("AAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEwLTAxLTExVDA5OjEyOjQ0LTA3OjAwjG3JoQAAADR0RVh0TGljZW5zZQBodHRwOi8vY3JlYXRpdmVjb21tb25zLm9yZy9saWNl");
            sb.Append("bnNlcy9HUEwvMi4wL2xqBqgAAAAZdEVYdFNvZnR3YXJlAHd3dy5pbmtzY2FwZS5vcmeb7jwaAAAAE3RFWHRTb3VyY2UAR05PTUUtQ29sb3JzqplE4gAAADF0RVh0U291");
            sb.Append("cmNlX1VSTABodHRwOi8vY29kZS5nb29nbGUuY29tL3AvZ25vbWUtY29sb3JzL1AdtesAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property DialogApply_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void DialogApply_Reset()
        {
            _DialogApply = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití DialogApply_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _DialogApply = null;
        #endregion
        #region Image DialogSave
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku document-save-3.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu DialogSave_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property DialogSave, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property DialogSave_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\LCS\Tools\GreenSchedule4\FrxEditor\Pics\16\document-save-3.png
        /// </remarks>
        public static System.Drawing.Image DialogSave_Cached
        {
            get
            {
                if (_DialogSave == null) _DialogSave = DialogSave;
                return _DialogSave;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku document-save-3.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image DialogSave_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití DialogSave_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property DialogSave_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\LCS\Tools\GreenSchedule4\FrxEditor\Pics\16\document-save-3.png
        /// </remarks>
        public static System.Drawing.Image DialogSave { get { return _ImageCreateFrom(_DialogSave_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru document-save-3.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití DialogSave_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property DialogSave_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\LCS\Tools\GreenSchedule4\FrxEditor\Pics\16\document-save-3.png
        /// </remarks>
        public static System.Drawing.Image DialogSave_FromFile { get { return _ImageCreateFrom(_DialogSave_string, "document-save-3.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru DialogSave
        /// </summary>
        /// <returns></returns>
        private static string _DialogSave_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1328);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAAG7AAABuwE67OPiAAAACXZwQWcAAAAQAAAAEABcxq3DAAAB");
            sb.Append("wUlEQVQ4y6WTPWgUURDHf+8leHvdqVckKWMrYmchiB9cl6AQsRJbS7WwkGAnGLRW7G1U7ExhobWdAcuDA1N4HhE0u7cf2d038yx2PXc9CyUD817x+P/nNzM8473nMLEI");
            sb.Append("sL629uPgIO/dunO39WgsgMVagzFgqPLxoy2CoLP/Znv76CJAmqS9peUlzp2/QJPHQCU0BmsN1oC1htevXjAajXozAlUl6AQERxZ4/u5Tm6I+DBXFjcEpRARV/d2CqOKc");
            sb.Append("w1q4fukkBmYk3nvU17d6krzEOYc0DVQVEWGaFVXFX+LKAe9Bva9S/TyBiuCcI84KXr790GphtiUPHs/G4AzOOVRkniCKMwZnTzfVNUUl9h6mSf4XAhXEOe7fvvnP+1dt");
            sb.Append("EIhUQ/yfEPlzBmUJwIOth3S73Rm+MaYWCNc2riIinFhdbc+gdI68KAAYDoc8e/KUNEu5t7nZqrq8ssL46xhRpayJK4OyJM9zAKIoIkkS4jgmDMP2RlRRUfr9Pp93d1tD");
            sb.Append("/B5F4bGgExCFEVmWkRfFnEGSJJRlSZamSJPAiFyMptP3YRgd3/u2x/qVywBMJpOWwZfxGPB83NnBLth9AHPY7/wT+9Ie9uKUqZ8AAAAldEVYdGNyZWF0ZS1kYXRlADIw");
            sb.Append("MDktMTEtMTVUMTc6MDI6MzQtMDc6MDC2544SAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEwLTAyLTIwVDIzOjI2OjE1LTA3OjAwBjtcgQAAACV0RVh0ZGF0ZTptb2RpZnkA");
            sb.Append("MjAxMC0wMS0xMVQwOToyNDozOC0wNzowMNX0vIoAAABndEVYdExpY2Vuc2UAaHR0cDovL2NyZWF0aXZlY29tbW9ucy5vcmcvbGljZW5zZXMvYnktc2EvMy4wLyBvciBo");
            sb.Append("dHRwOi8vY3JlYXRpdmVjb21tb25zLm9yZy9saWNlbnNlcy9MR1BMLzIuMS9bjzxjAAAAJXRFWHRtb2RpZnktZGF0ZQAyMDA5LTAzLTE5VDEwOjUyOjUwLTA2OjAw2R/2");
            sb.Append("sgAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAAATdEVYdFNvdXJjZQBPeHlnZW4gSWNvbnPsGK7oAAAAJ3RFWHRTb3VyY2VfVVJMAGh0dHA6Ly93");
            sb.Append("d3cub3h5Z2VuLWljb25zLm9yZy/vN6rLAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property DialogSave_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void DialogSave_Reset()
        {
            _DialogSave = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití DialogSave_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _DialogSave = null;
        #endregion
        #region Image DialogCancel
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku dialog-cancel.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu DialogCancel_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property DialogCancel, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property DialogCancel_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\LCS\Tools\GreenSchedule4\FrxEditor\Pics\16\dialog-cancel.png
        /// </remarks>
        public static System.Drawing.Image DialogCancel_Cached
        {
            get
            {
                if (_DialogCancel == null) _DialogCancel = DialogCancel;
                return _DialogCancel;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku dialog-cancel.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image DialogCancel_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití DialogCancel_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property DialogCancel_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\LCS\Tools\GreenSchedule4\FrxEditor\Pics\16\dialog-cancel.png
        /// </remarks>
        public static System.Drawing.Image DialogCancel { get { return _ImageCreateFrom(_DialogCancel_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru dialog-cancel.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití DialogCancel_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property DialogCancel_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// D:\LCS\Tools\GreenSchedule4\FrxEditor\Pics\16\dialog-cancel.png
        /// </remarks>
        public static System.Drawing.Image DialogCancel_FromFile { get { return _ImageCreateFrom(_DialogCancel_string, "dialog-cancel.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru DialogCancel
        /// </summary>
        /// <returns></returns>
        private static string _DialogCancel_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1756);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAANkE3LLaAgAAAAZiS0dEAAAAAAAA+UO7fwAAAAlwSFlzAAAASAAAAEgARslrPgAAAAl2cEFn");
            sb.Append("AAAAEAAAABAAXMatwwAAA45JREFUOMtF0b1vG2UAx/Hf8zz35jvbpziOXSdulKRJ3JYmKlFTBCJiKC9CVSpVQkIMTOwVA1SVAFUIFsSbulS0QsDUoUNFBQEiVQpNoiJM");
            sb.Append("SofEcZ1A0ja+4Nic7+qc7813PoYOfP+Az/IlbYCQmZmCODHxUUQI81dX37u/uHh/WFWjnsePAQD7hQKcSoVTz559iRscfL/bat12i8XPo0ZD5/zx8eHk5OTb9OTJV0EI");
            sb.Append("BEEwDjvOJ7FiceMhIUimUmhUKrT/9OnnuKmpd+jY2DRtNodF19X/nZ//mv6m68/UNW02sm0FjCns0KE3hOnpD5wTJ8YvA+g0m6z/1KkZfmLiY5rLvYAw5IN2O/dI015f");
            sb.Append("sO0RlnWcKXt39+Ve348nenpARJGnkjRGKU3N+P6GVCgc4Y8du0jz+edBCAurVWzOzeHWysre7647xzIAZ3veuKtpI2nXpQlVBeF5ngpCgfL8UZbNztJc7lkALNQ0bMzP");
            sb.Append("49a9e9aq79/cBn5mJqBLwG7U6Qx1arV82vdZXFGeILI8QmR5AFFEw1oN28vL+LVUstY6nRtl4NIC8JANAeEdYKcPeIAg6I8ajcEswGKqCkQRQRAQWBZ2i0Usrq9ba0Fw");
            sb.Append("vQR8dhsoK0DElQAcB4KbwHKaUo6T5X7CcZPwPIDjAAAIArBYrCvE43cemealBWD9IBDtAOD2EgmokgTm+4KjqgNcPp+UMhkgDIFOB6AUIATZTIac8bzsrGEMXiOkEkmS");
            sb.Append("V7UssE+TSbjdboITxTclnj/Pc9wIAUjY6aBRrcI1TUhRBGpZhA+CDMfYUVCqu77/d7+iBOyCKGZEQXiLSdJ5oihDUBQSCgL+qddRqVR8vdnsSvE4k9NpEFEkhNIcBY5z");
            sb.Append("hOx7QbDF3pXlc5IknSOJxAB6ehD09qLeamFzc1Mv7e9/b/j+FnPdg1ImI8ayWVDGQIAUguApy/MM9hohFxRZflrs6yNhXx/qhoGtcrm2ZppXfwS+0IClpG0LfKs1KqRS");
            sb.Append("sdiBAyDdLsxmM1HZ2zPYi0HwChdFh6Vcjmt5HrbX1nZWTfOrH4CrvwDVdUAXgbLqOFQwjFEhmYx3ggBb5bK9YRhLbBSwFCDLx2L5hqY9+LPR+PIG8N08UP/wyUSUAPMi");
            sb.Append("sJ60bUdqt8fsdpv/q1b7aSUMv+GuAEtdQki71WrprvvHdeDaEqAz/F8agA7susC3oePQZBQduUvIlcvA3f8A+J+WVvlUkfcAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTAt");
            sb.Append("MDItMTdUMDc6MTI6MjctMDc6MDAAloH6AAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEwLTAxLTMxVDA3OjMzOjAyLTA3OjAw8oO86QAAADV0RVh0TGljZW5zZQBodHRwOi8v");
            sb.Append("Y3JlYXRpdmVjb21tb25zLm9yZy9saWNlbnNlcy9MR1BMLzIuMS87wbQYAAAAHHRFWHRTb3VyY2UAQ3J5c3RhbCBDbGVhciBQcm9qZWN0hcGKNwAAADp0RVh0U291cmNl");
            sb.Append("X1VSTABodHRwOi8vY29tbW9ucy53aWtpbWVkaWEub3JnL3dpa2kvQ3J5c3RhbF9DbGVhcq++RWMAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property DialogCancel_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void DialogCancel_Reset()
        {
            _DialogCancel = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití DialogCancel_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _DialogCancel = null;
        #endregion
        #region Image EditUndo
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku edit-undo-3.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu EditUndo_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property EditUndo, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property EditUndo_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\FrxEditor\Pics\16\edit-undo-3.png
        /// </remarks>
        public static System.Drawing.Image EditUndo_Cached
        {
            get
            {
                if (_EditUndo == null) _EditUndo = EditUndo;
                return _EditUndo;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku edit-undo-3.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image EditUndo_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití EditUndo_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property EditUndo_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\FrxEditor\Pics\16\edit-undo-3.png
        /// </remarks>
        public static System.Drawing.Image EditUndo { get { return _ImageCreateFrom(_EditUndo_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru edit-undo-3.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití EditUndo_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property EditUndo_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\FrxEditor\Pics\16\edit-undo-3.png
        /// </remarks>
        public static System.Drawing.Image EditUndo_FromFile { get { return _ImageCreateFrom(_EditUndo_string, "edit-undo-3.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru EditUndo
        /// </summary>
        /// <returns></returns>
        private static string _EditUndo_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1208);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAAuHAAALhwGTQIdTAAAACXZwQWcAAAAQAAAAEABcxq3DAAAB");
            sb.Append("wklEQVQ4y6WTzUtUURjGf/fcO9EoRFZCtAmRNgbRKmjRH1DiQlwYhdwBUakcYlYtp0Foe4khaBzEe/1A2hQotoikhRC0METQmERoQhBsopi+Ls71vC2muc2oIxO9u/Px");
            sb.Append("/N734TwH6pTrIDRQ6n/EBwJcB7Fvv2lUj7VPfGsBCPZN8j6izj8Y1mt1Sa6DiP9KpJgS+flEpLQqsrMkUnonUrgqroOk0urOXp1R09mfrTJ3Gswz5WkilyBYw8v0krfU");
            sb.Append("cDKuH1Wuma6D2ANZ2FmsRct3kG+gToIuwJELXOwo8eHt0rWOLjWz+Fw+A1h5Sw152YGM3dfFRm7uQHvtbS3QMgXRGwRBliZTbgLJ0EIqrQbPBjpj93WykZun/dwVONrz");
            sb.Append("x8oJMJrRKJR5HPyneONpYomy1qh0qYagi3jTfy1pDdftMaLRY6AsvMfdISDMQTKuR/OWGvIm58E8BUAsgRFLYPwwWX79sh/kF4hfP0ghZOJZzaVtU93b3AKMZtjdPDyJ");
            sb.Append("FUj13khcvyi/TJHCpy/1k1gNAUbDdVr1EmjY/cj6+go+3OdfynUQ+ZoQ2b4sez+a1QhgyzQeeuPOXYBcRLWCDs9+AzkHwCHMdHk0AAAAJXRFWHRjcmVhdGUtZGF0ZQAy");
            sb.Append("MDA5LTExLTE1VDIzOjA0OjA1LTA3OjAwL9m9TwAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMC0wMi0yMFQyMzoyNjoxNS0wNzowMAY7XIEAAAAldEVYdGRhdGU6bW9kaWZ5");
            sb.Append("ADIwMTAtMDEtMTFUMDk6MDg6MzktMDc6MDAx0+5xAAAANHRFWHRMaWNlbnNlAGh0dHA6Ly9jcmVhdGl2ZWNvbW1vbnMub3JnL2xpY2Vuc2VzL0dQTC8yLjAvbGoGqAAA");
            sb.Append("ACV0RVh0bW9kaWZ5LWRhdGUAMjAwOS0xMS0xNVQyMzowNDowNS0wNzowMHBoy3sAAAAXdEVYdFNvdXJjZQBHTk9NRSBJY29uIFRoZW1lwfkmaQAAACB0RVh0U291cmNl");
            sb.Append("X1VSTABodHRwOi8vYXJ0Lmdub21lLm9yZy8y5JF5AAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property EditUndo_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void EditUndo_Reset()
        {
            _EditUndo = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití EditUndo_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _EditUndo = null;
        #endregion
        #region Image EditRedo
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku edit-redo-3.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu EditRedo_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property EditRedo, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property EditRedo_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\FrxEditor\Pics\16\edit-redo-3.png
        /// </remarks>
        public static System.Drawing.Image EditRedo_Cached
        {
            get
            {
                if (_EditRedo == null) _EditRedo = EditRedo;
                return _EditRedo;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku edit-redo-3.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image EditRedo_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití EditRedo_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property EditRedo_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\FrxEditor\Pics\16\edit-redo-3.png
        /// </remarks>
        public static System.Drawing.Image EditRedo { get { return _ImageCreateFrom(_EditRedo_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru edit-redo-3.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití EditRedo_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property EditRedo_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\FrxEditor\Pics\16\edit-redo-3.png
        /// </remarks>
        public static System.Drawing.Image EditRedo_FromFile { get { return _ImageCreateFrom(_EditRedo_string, "edit-redo-3.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru EditRedo
        /// </summary>
        /// <returns></returns>
        private static string _EditRedo_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1176);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAAuHAAALhwGTQIdTAAAACXZwQWcAAAAQAAAAEABcxq3DAAAB");
            sb.Append("qElEQVQ4y42TUWhSURiAv+vEmr6F2nuBRMF6lKCXCgJfHPQi3LF6KK4bK+itFhTspbegwLEhxKCgooix2/YSoRQEPQwmwwkmJRU6yxKnkXL1enpo165elfs/nv983/nP");
            sb.Append("+f8DNiIcd4lhOYcdwSiJbcHipQ8DJc4hpx0HdsxrQmpz/2ICOCtURZNGlToXjrvE44osyq2cKGrb4kcrK9KNNZGs3xP55nthrkTqh4HY3ekX+JwBCq0tHDipdUr81svd");
            sb.Append("fccOnOf6o3OoiiZJJjgAZC9HrnHKrVBqp9FFi196Hq3zx1Lp4fZJFl7KPW8wJerjTBy8QFX/xkbtFsXPlYHXDPpklhMyQNQsuDNz5SoAD79MEXCE8Ht7wdTPDYJemeeJ");
            sb.Append("JYCoqmjxni4ccZ1mvXaTgCPE2voqeBrd3OQZ+R+c/A9b5qBNE3f1KLlPH8HTSKmKJhktc48dssAWwZ6+C0Dm6ybADXPu6ZuYBbYIVt7exu/zA6Aq2uu+t7PA/YIT5UKd");
            sb.Append("pqgbbY0Yif2rWOAegapoGYDq9wazkXmAZ9iI/r/ge/XuiTFyD+wI/gKvfrEdDwZeuAAAACV0RVh0Y3JlYXRlLWRhdGUAMjAwOS0xMS0xNVQyMzowNDowNS0wNzowMC/Z");
            sb.Append("vU8AAAAldEVYdGRhdGU6Y3JlYXRlADIwMTAtMDItMjBUMjM6MjY6MTUtMDc6MDAGO1yBAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEwLTAxLTExVDA5OjA4OjM4LTA3OjAw");
            sb.Append("l6TlxQAAADR0RVh0TGljZW5zZQBodHRwOi8vY3JlYXRpdmVjb21tb25zLm9yZy9saWNlbnNlcy9HUEwvMi4wL2xqBqgAAAAldEVYdG1vZGlmeS1kYXRlADIwMDktMTEt");
            sb.Append("MTVUMjM6MDQ6MDUtMDc6MDBwaMt7AAAAF3RFWHRTb3VyY2UAR05PTUUgSWNvbiBUaGVtZcH5JmkAAAAgdEVYdFNvdXJjZV9VUkwAaHR0cDovL2FydC5nbm9tZS5vcmcv");
            sb.Append("MuSReQAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property EditRedo_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void EditRedo_Reset()
        {
            _EditRedo = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití EditRedo_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _EditRedo = null;
        #endregion
        #region Image WindowNew
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku window-new.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu WindowNew_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property WindowNew, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property WindowNew_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\FrxSupport\Pics\source16\window-new.png
        /// </remarks>
        public static System.Drawing.Image WindowNew_Cached
        {
            get
            {
                if (_WindowNew == null) _WindowNew = WindowNew;
                return _WindowNew;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku window-new.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image WindowNew_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití WindowNew_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property WindowNew_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\FrxSupport\Pics\source16\window-new.png
        /// </remarks>
        public static System.Drawing.Image WindowNew { get { return _ImageCreateFrom(_WindowNew_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru window-new.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití WindowNew_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property WindowNew_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\FrxSupport\Pics\source16\window-new.png
        /// </remarks>
        public static System.Drawing.Image WindowNew_FromFile { get { return _ImageCreateFrom(_WindowNew_string, "window-new.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru WindowNew
        /// </summary>
        /// <returns></returns>
        private static string _WindowNew_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(4580);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGOfPtRkwAAACBjSFJNAACHDwAAjA8AAP1SAACBQAAAfXkAAOmLAAA85QAAGcxzPIV3AAAK");
            sb.Append("J2lDQ1BpY2MAAEjHnZZ3VFTXFofPvXd6oc0wAlKG3rvAANJ7k15FYZgZYCgDDjM0sSGiAhFFRJoiSFDEgNFQJFZEsRAUVLAHJAgoMRhFVCxvRtaLrqy89/Ly++Osb+2z");
            sb.Append("97n77L3PWhcAkqcvl5cGSwGQyhPwgzyc6RGRUXTsAIABHmCAKQBMVka6X7B7CBDJy82FniFyAl8EAfB6WLwCcNPQM4BOB/+fpFnpfIHomAARm7M5GSwRF4g4JUuQLrbP");
            sb.Append("ipgalyxmGCVmvihBEcuJOWGRDT77LLKjmNmpPLaIxTmns1PZYu4V8bZMIUfEiK+ICzO5nCwR3xKxRoowlSviN+LYVA4zAwAUSWwXcFiJIjYRMYkfEuQi4uUA4EgJX3Hc");
            sb.Append("VyzgZAvEl3JJS8/hcxMSBXQdli7d1NqaQffkZKVwBALDACYrmcln013SUtOZvBwAFu/8WTLi2tJFRbY0tba0NDQzMv2qUP91829K3NtFehn4uWcQrf+L7a/80hoAYMyJ");
            sb.Append("arPziy2uCoDOLQDI3fti0zgAgKSobx3Xv7oPTTwviQJBuo2xcVZWlhGXwzISF/QP/U+Hv6GvvmckPu6P8tBdOfFMYYqALq4bKy0lTcinZ6QzWRy64Z+H+B8H/nUeBkGc");
            sb.Append("eA6fwxNFhImmjMtLELWbx+YKuGk8Opf3n5r4D8P+pMW5FonS+BFQY4yA1HUqQH7tBygKESDR+8Vd/6NvvvgwIH554SqTi3P/7zf9Z8Gl4iWDm/A5ziUohM4S8jMX98TP");
            sb.Append("EqABAUgCKpAHykAd6ABDYAasgC1wBG7AG/iDEBAJVgMWSASpgA+yQB7YBApBMdgJ9oBqUAcaQTNoBcdBJzgFzoNL4Bq4AW6D+2AUTIBnYBa8BgsQBGEhMkSB5CEVSBPS");
            sb.Append("h8wgBmQPuUG+UBAUCcVCCRAPEkJ50GaoGCqDqqF6qBn6HjoJnYeuQIPQXWgMmoZ+h97BCEyCqbASrAUbwwzYCfaBQ+BVcAK8Bs6FC+AdcCXcAB+FO+Dz8DX4NjwKP4Pn");
            sb.Append("EIAQERqiihgiDMQF8UeikHiEj6xHipAKpAFpRbqRPuQmMorMIG9RGBQFRUcZomxRnqhQFAu1BrUeVYKqRh1GdaB6UTdRY6hZ1Ec0Ga2I1kfboL3QEegEdBa6EF2BbkK3");
            sb.Append("oy+ib6Mn0K8xGAwNo42xwnhiIjFJmLWYEsw+TBvmHGYQM46Zw2Kx8lh9rB3WH8vECrCF2CrsUexZ7BB2AvsGR8Sp4Mxw7rgoHA+Xj6vAHcGdwQ3hJnELeCm8Jt4G749n");
            sb.Append("43PwpfhGfDf+On4Cv0CQJmgT7AghhCTCJkIloZVwkfCA8JJIJKoRrYmBRC5xI7GSeIx4mThGfEuSIemRXEjRJCFpB+kQ6RzpLuklmUzWIjuSo8gC8g5yM/kC+RH5jQRF");
            sb.Append("wkjCS4ItsUGiRqJDYkjiuSReUlPSSXK1ZK5kheQJyeuSM1J4KS0pFymm1HqpGqmTUiNSc9IUaVNpf+lU6RLpI9JXpKdksDJaMm4ybJkCmYMyF2TGKQhFneJCYVE2Uxop");
            sb.Append("FykTVAxVm+pFTaIWU7+jDlBnZWVkl8mGyWbL1sielh2lITQtmhcthVZKO04bpr1borTEaQlnyfYlrUuGlszLLZVzlOPIFcm1yd2WeydPl3eTT5bfJd8p/1ABpaCnEKiQ");
            sb.Append("pbBf4aLCzFLqUtulrKVFS48vvacIK+opBimuVTyo2K84p6Ss5KGUrlSldEFpRpmm7KicpFyufEZ5WoWiYq/CVSlXOavylC5Ld6Kn0CvpvfRZVUVVT1Whar3qgOqCmrZa");
            sb.Append("qFq+WpvaQ3WCOkM9Xr1cvUd9VkNFw08jT6NF454mXpOhmai5V7NPc15LWytca6tWp9aUtpy2l3audov2Ax2yjoPOGp0GnVu6GF2GbrLuPt0berCehV6iXo3edX1Y31Kf");
            sb.Append("q79Pf9AAbWBtwDNoMBgxJBk6GWYathiOGdGMfI3yjTqNnhtrGEcZ7zLuM/5oYmGSYtJoct9UxtTbNN+02/R3Mz0zllmN2S1zsrm7+QbzLvMXy/SXcZbtX3bHgmLhZ7HV");
            sb.Append("osfig6WVJd+y1XLaSsMq1qrWaoRBZQQwShiXrdHWztYbrE9Zv7WxtBHYHLf5zdbQNtn2iO3Ucu3lnOWNy8ft1OyYdvV2o/Z0+1j7A/ajDqoOTIcGh8eO6o5sxybHSSdd");
            sb.Append("pySno07PnU2c+c7tzvMuNi7rXM65Iq4erkWuA24ybqFu1W6P3NXcE9xb3Gc9LDzWepzzRHv6eO7yHPFS8mJ5NXvNelt5r/Pu9SH5BPtU+zz21fPl+3b7wX7efrv9HqzQ");
            sb.Append("XMFb0ekP/L38d/s/DNAOWBPwYyAmMCCwJvBJkGlQXlBfMCU4JvhI8OsQ55DSkPuhOqHC0J4wybDosOaw+XDX8LLw0QjjiHUR1yIVIrmRXVHYqLCopqi5lW4r96yciLaI");
            sb.Append("LoweXqW9KnvVldUKq1NWn46RjGHGnIhFx4bHHol9z/RnNjDn4rziauNmWS6svaxnbEd2OXuaY8cp40zG28WXxU8l2CXsTphOdEisSJzhunCruS+SPJPqkuaT/ZMPJX9K");
            sb.Append("CU9pS8Wlxqae5Mnwknm9acpp2WmD6frphemja2zW7Fkzy/fhN2VAGasyugRU0c9Uv1BHuEU4lmmfWZP5Jiss60S2dDYvuz9HL2d7zmSue+63a1FrWWt78lTzNuWNrXNa");
            sb.Append("V78eWh+3vmeD+oaCDRMbPTYe3kTYlLzpp3yT/LL8V5vDN3cXKBVsLBjf4rGlpVCikF84stV2a9021DbutoHt5turtn8sYhddLTYprih+X8IqufqN6TeV33zaEb9joNSy");
            sb.Append("dP9OzE7ezuFdDrsOl0mX5ZaN7/bb3VFOLy8qf7UnZs+VimUVdXsJe4V7Ryt9K7uqNKp2Vr2vTqy+XeNc01arWLu9dn4fe9/Qfsf9rXVKdcV17w5wD9yp96jvaNBqqDiI");
            sb.Append("OZh58EljWGPft4xvm5sUmoqbPhziHRo9HHS4t9mqufmI4pHSFrhF2DJ9NProje9cv+tqNWytb6O1FR8Dx4THnn4f+/3wcZ/jPScYJ1p/0Pyhtp3SXtQBdeR0zHYmdo52");
            sb.Append("RXYNnvQ+2dNt293+o9GPh06pnqo5LXu69AzhTMGZT2dzz86dSz83cz7h/HhPTM/9CxEXbvUG9g5c9Ll4+ZL7pQt9Tn1nL9tdPnXF5srJq4yrndcsr3X0W/S3/2TxU/uA");
            sb.Append("5UDHdavrXTesb3QPLh88M+QwdP6m681Lt7xuXbu94vbgcOjwnZHokdE77DtTd1PuvriXeW/h/sYH6AdFD6UeVjxSfNTws+7PbaOWo6fHXMf6Hwc/vj/OGn/2S8Yv7ycK");
            sb.Append("npCfVEyqTDZPmU2dmnafvvF05dOJZ+nPFmYKf5X+tfa5zvMffnP8rX82YnbiBf/Fp99LXsq/PPRq2aueuYC5R69TXy/MF72Rf3P4LeNt37vwd5MLWe+x7ys/6H7o/ujz");
            sb.Append("8cGn1E+f/gUDmPP8atgFYAAAAAlwSFlzAAALEgAACxIB0t1+/AAAABZ0RVh0U291cmNlAENyeXN0YWwgUHJvamVjdOvj5IsAAAAadEVYdFNvZnR3YXJlAFBhaW50Lk5F");
            sb.Append("VCB2My41LjExR/NCNwAAAmRJREFUOE+dk91LU2Ecxx/ooqvoqheSIspebLVW0JzkH+CFBaYUS+b7NNScm9N5ttZcmgZFDYkiyaSSZBdBkbSUlMIuiqSoVVY6e6GcTm3p");
            sb.Append("trOXs/nteZ6KtCvxC5+L34Hvh+f3nHNIl8vtcdwbjZtvjcDc+RHCzQ8QbrxHXcdbGNvdMFx9BUPbS+ivvEA1RXfpOSovPoO57UkwS++sIM23PWjtGV8SOsfjBLF0jWCp");
            sb.Append("lJ59BGLuHMZSU9zSB8J2ZolIcYSjEsSIhGBYwkwoih/BCKZmRfh+ihifDsE7GcI3XwCj3lneKTjdSwX0wlgWCCizYhT+YBTTgTAmZ0RM+ENcMjYVxJfxAO/kNz74J4hS");
            sb.Append("QSQmcUmIEgjH6CliXNJwzYrD9hzkCNkod5Tzk7Dk2V0gpuvv+BCLxxGlRCQqofyW0FXEGFSCEsKggXOgPhM+f5h3NLb7ILUdb/ggJRKIUZiEIdLTsFWYRCakoGGonpNc");
            sb.Append("vIneS4R3cq3dIMb213xgAi6hZYaqUIW9mj1I1aRCbpWhxWvjrM9ahyJbIdR2NdR1ZSA19Etjic/Ncf6K5CUKHOrPgNajxqlpE4TvVbBNGGH5Wg2LhzJsgCovDUR3eZAL");
            sb.Append("EvMkjJT8nQsE5jEdTnj1qP1UgfrPOtQNHYeiSgFS2fqUC/6P7OgurNQux4rGZVjbtAqpA9s4u5tk2H9BiTT7PmSaDoLQH8J57PwASs70o6j5IQqaeun77UHuyW6oLXdx");
            sb.Append("xHwHSedWI8OdxtlQthnZNU7QHsNJFpMkyxqku+Scjdpk/Hm8+GzX7MCW0q0cZXX6PAEhvwBlDc84pO5WfgAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property WindowNew_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void WindowNew_Reset()
        {
            _WindowNew = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití WindowNew_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _WindowNew = null;
        #endregion
        #region Image WindowNewDuplicate
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku window-new-duplicate.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu WindowNewDuplicate_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property WindowNewDuplicate, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property WindowNewDuplicate_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\FrxSupport\Pics\source16\window-new-duplicate.png
        /// </remarks>
        public static System.Drawing.Image WindowNewDuplicate_Cached
        {
            get
            {
                if (_WindowNewDuplicate == null) _WindowNewDuplicate = WindowNewDuplicate;
                return _WindowNewDuplicate;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku window-new-duplicate.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image WindowNewDuplicate_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití WindowNewDuplicate_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property WindowNewDuplicate_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\FrxSupport\Pics\source16\window-new-duplicate.png
        /// </remarks>
        public static System.Drawing.Image WindowNewDuplicate { get { return _ImageCreateFrom(_WindowNewDuplicate_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru window-new-duplicate.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití WindowNewDuplicate_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property WindowNewDuplicate_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\FrxSupport\Pics\source16\window-new-duplicate.png
        /// </remarks>
        public static System.Drawing.Image WindowNewDuplicate_FromFile { get { return _ImageCreateFrom(_WindowNewDuplicate_string, "window-new-duplicate.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru WindowNewDuplicate
        /// </summary>
        /// <returns></returns>
        private static string _WindowNewDuplicate_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1004);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwwAADsMBx2+oZAAAABt0RVh0U291cmNlAEZBTUZBTUZBTSBT");
            sb.Append("aWxrIEljb25zgnpk+wAAABp0RVh0U29mdHdhcmUAUGFpbnQuTkVUIHYzLjUuMTFH80I3AAACRElEQVQ4T5WS3UtTYRzHD3TRVXTVC0kRZS+2WitoL+Qf4IUFUwkmjLV0");
            sb.Append("Jr5tbjl3zpQ5dRn0NiSKpCRKkgN1UV2IZVL6XBRJURZW81gEtboIIgyznfntd54dwlMR6wsfODwv34fn8xzB2SyXnbyhjEhXp5k08JqJl1+ylv7nLHTxGQv2PWGB84+Z");
            sb.Append("/+wj1nDmIZP62Ii2XlicxDVlrHf4I8sXf/L+mL41l+jgNPsfao7fY/rWXKSBFAOQN1U9d40F4pVXfOJ7RmWDQ5NK8taMSj5APkA+QD5APkA+QD5APkA+QD5myUe9oEnT");
            sb.Append("Cn6oKjt6XQHdM2/IR1YIX3rBCzLZrHZH/I2O/nYciFegQixHXbLu1zj5gBC68JQXqAsL9Iwp+vwzdtEKcSLI2Rcp1UcB8gHBf26CF2QJ8sEnyAfm5jOYncvgy7d5mMQi");
            sb.Append("dExFOIVVGzCT/srXHUzchtDQ+4AXaGjStJAP2L127Hbvgs1tg7ndhJ50jLPWuQaHYl644i64wrXQ/sTO2lPjrPrYKCMfvIB8wFxtQdloCXyKC52fWyG+b0Ls0xFE3wUQ");
            sb.Append("VYhUEHaPA/pj5kI+eAH5QJFnu6FA+uBHW7oZLW/qEXnrR3iqEZYmi7GAfPAC8gFT5Q4s9y3Fsq4lWN29ArbxLZyd3SbsPW2FI74Hpa37jQXkgxf8noITK1Ey6eCsO7xR");
            sb.Append("HwWcQdlYQD5k8gHyAW/iDjxdw6hsu4mC6CoUD5k5632FKA/JoLUasr7139nq3oZNNZs51kDxolMF4Sdt7XY5xzQ5ewAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property WindowNewDuplicate_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void WindowNewDuplicate_Reset()
        {
            _WindowNewDuplicate = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití WindowNewDuplicate_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _WindowNewDuplicate = null;
        #endregion
        #region Image WindowEdit
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku window-edit.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu WindowEdit_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property WindowEdit, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property WindowEdit_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\FrxSupport\Pics\source16\window-edit.png
        /// </remarks>
        public static System.Drawing.Image WindowEdit_Cached
        {
            get
            {
                if (_WindowEdit == null) _WindowEdit = WindowEdit;
                return _WindowEdit;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku window-edit.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image WindowEdit_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití WindowEdit_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property WindowEdit_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\FrxSupport\Pics\source16\window-edit.png
        /// </remarks>
        public static System.Drawing.Image WindowEdit { get { return _ImageCreateFrom(_WindowEdit_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru window-edit.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití WindowEdit_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property WindowEdit_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\FrxSupport\Pics\source16\window-edit.png
        /// </remarks>
        public static System.Drawing.Image WindowEdit_FromFile { get { return _ImageCreateFrom(_WindowEdit_string, "window-edit.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru WindowEdit
        /// </summary>
        /// <returns></returns>
        private static string _WindowEdit_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1596);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAAAZiS0dEAAAAAAAA+UO7fwAAAAlwSFlzAAAASAAAAEgARslrPgAAAAl2cEFn");
            sb.Append("AAAAEAAAABAAXMatwwAAAmpJREFUOMulk01I1FEUxX9v/M/kx9iQkQahphURFlFYEE7hqiAKKkgKIihCiLAIolq064NqUVhUVLaMNEJCqEW1iWQKAnUM0+zDRMaP0nEU");
            sb.Append("/Ts68+5tMebCaiG91eVx73nnnvOOUVX+55jdJ+uOBctLr0RdzVIFRFARrFhUFFFBrUVUUWuxIsz3Jcbb2yNn6q9V3HJKy0pveNOzPHnpc3o4a9y1N4BbjptQjxsdmzP1");
            sb.Append("iYR6ABy1yrk9S+YMUFXdTQpABVUlJaWCAsbQ3NT0x1DGVBh/fyNp/jVU5b6m9fbxgw6qWGuprP4+03j/xFIAgsHgzJ3b18BoRw8Zaw4QKFpHrGslHS9qrjpWUgrfrSoE");
            sb.Append("o6AGmWWt2/ecyVgLOSvKiH5tx2emyJ6/GP/CgoCjoogVjAGV6TWMUlJSQiw2THL4LWnuOwLF25jsq8WXaehu6WDUBTMZXesRsYhYktZip2tJCm1tbXxuekTaeCOBZduJ");
            sb.Append("997HeIfx+rPJsEM8jGxiQ1V9p5NMJLDWcuLewAzl6so8kj9DLM+PEli+i3jkDh5vkqnRIoZCYTI2n6W3rX/aBSuICNeP5KboA9GvL8nLHCS3ZCdT/TWk+ZT4SCGDoWYK");
            sb.Append("9tUw5BpUelMAIoKIAoIBeloa8JsekmYJfR9usiDXRzyaT/T9R9LLLzI4nrL6t9BOpKv78fm6RIVYi1hhq3nC3qMP+FR7is43IeYVrGVkIMKz+H4GOr+g0okIAI8BzOw0");
            sb.Append("XqhcnTh9+KiDx9Ly6indXZ/HAotyglsvhcN/TeNsgIotORPri/OcjauKUO9kaOLHz0M7Lrd++9eX/gX6RERT50pEvwAAACV0RVh0Y3JlYXRlLWRhdGUAMjAwOS0xMS0x");
            sb.Append("NlQyMjoxODoxNi0wNzowMP139XUAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTAtMDEtMTFUMDY6NTI6NDUtMDc6MDDM7tweAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEwLTAx");
            sb.Append("LTExVDA2OjUyOjQ1LTA3OjAwvbNkogAAAGJ0RVh0TGljZW5zZQBodHRwOi8vY3JlYXRpdmVjb21tb25zLm9yZy9saWNlbnNlcy9ieS8zLjAvIG9yIGh0dHA6Ly9jcmVh");
            sb.Append("dGl2ZWNvbW1vbnMub3JnL2xpY2Vuc2VzL2J5LzIuNS+LhjxlAAAAJXRFWHRtb2RpZnktZGF0ZQAyMDA2LTAzLTEyVDIxOjQ4OjIyLTA3OjAwDeMJTQAAABl0RVh0U29m");
            sb.Append("dHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAAbdEVYdFNvdXJjZQBGQU1GQU1GQU0gU2lsayBJY29uc4J6ZPsAAAAzdEVYdFNvdXJjZV9VUkwAaHR0cDovL3d3dy5m");
            sb.Append("YW1mYW1mYW0uY29tL2xhYi9pY29ucy9zaWxrL8LEDQ0AAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property WindowEdit_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void WindowEdit_Reset()
        {
            _WindowEdit = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití WindowEdit_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _WindowEdit = null;
        #endregion
        #region Image WindowClose
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku window-close.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu WindowClose_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property WindowClose, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property WindowClose_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\FrxSupport\Pics\source16\window-close.png
        /// </remarks>
        public static System.Drawing.Image WindowClose_Cached
        {
            get
            {
                if (_WindowClose == null) _WindowClose = WindowClose;
                return _WindowClose;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku window-close.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image WindowClose_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití WindowClose_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property WindowClose_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\FrxSupport\Pics\source16\window-close.png
        /// </remarks>
        public static System.Drawing.Image WindowClose { get { return _ImageCreateFrom(_WindowClose_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru window-close.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití WindowClose_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property WindowClose_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\DavidPrac\VSProjects\ReportEditor\FrxSupport\Pics\source16\window-close.png
        /// </remarks>
        public static System.Drawing.Image WindowClose_FromFile { get { return _ImageCreateFrom(_WindowClose_string, "window-close.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru WindowClose
        /// </summary>
        /// <returns></returns>
        private static string _WindowClose_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1324);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAA3XAAAN1wFCKJt4AAAACXZwQWcAAAAQAAAAEABcxq3DAAAC");
            sb.Append("R0lEQVQ4y6VTQU/iQBh9U7qQlrYYg7uLlOXA3kyMRy9rW7xx4LQHf2LPvRETbfXkgcSQGE8eQFi2Io20WCyd6ezBhYgHL36nyffefPneezOEc47PlLg6uJYl5mYzG4SA");
            sb.Append("adqJeX5O3xJdyxJzYWgD2MCFFUimU0euVltytdoi06njWtbGcBIETlHXW7Kut0gQrHERAPhkYiu1mlk7PpZACAadjjnv9x3XstoAgIcHp1ivm3qzKYFzDDodM7q/twH8");
            sb.Append("FgEgoxTZcolssUAWhtANQxqcnprRcOgAgKrrpm4YEvV9CJr2ymUMAEA453AJEdNGw1ErFbPebEpZFEHQNNx73jMA1AyjmEURBEXB4OwsDsdj78vdXdvknJJVCi4hYlKv");
            sb.Append("O2qlYvw4OpKz+Rw5VQUAsDCEoKoYXFzE0XjsFfr9tsk5XW+wNosQcaHrjra7+6t6eKiA/g9CFDG6upqHo9GlNByuL2/EuCpGKehyCbpYAFn22kxT0CQBo/Q9HRsSwp0d");
            sb.Append("Ry6XjerBgZwlCXKS9Dr05QVCPo/R9XUcPz562mSyKcElRHza3nbkrS3j+/6+zJdLkHweDzc3cwD4urenrHp/e704fnrytoKgbXJOBQAISiU7Xywa5UZDTmczMEox7Hbj");
            sb.Append("me9fznz/ctjtxoxSpGGIcqMh54tFIyiV7LUHjDGwNEUaxwCAye1t/BJFXvn5uQ0Aj4w5f3o9Y+fnTxmcI0tTsPfvwC8UnIKiGACQzOfetyRZ6/wI3zBxnMvZAFBh7ORt");
            sb.Append("VB/h5LPf+R+0911LhE5qiwAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMC0wMS0xMVQwOToxMjo0Mi0wNzowMJ7gRCcAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTAtMDEtMTFU");
            sb.Append("MDk6MTI6NDItMDc6MDDvvfybAAAANHRFWHRMaWNlbnNlAGh0dHA6Ly9jcmVhdGl2ZWNvbW1vbnMub3JnL2xpY2Vuc2VzL0dQTC8yLjAvbGoGqAAAABl0RVh0U29mdHdh");
            sb.Append("cmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAAATdEVYdFNvdXJjZQBHTk9NRS1Db2xvcnOqmUTiAAAAMXRFWHRTb3VyY2VfVVJMAGh0dHA6Ly9jb2RlLmdvb2dsZS5jb20v");
            sb.Append("cC9nbm9tZS1jb2xvcnMvUB216wAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property WindowClose_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void WindowClose_Reset()
        {
            _WindowClose = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití WindowClose_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _WindowClose = null;
        #endregion
        #region SPOLEČNÉ METODY PRO KONVERZI
        /// <summary>
        /// Vrátí Image z definice (string). Image generuje buď v paměti, anebo s pomocí souboru.
        /// Pokud není zadán parametr (cacheFileName) (když je null), generuje se Image v paměti.
        /// Pokud je soubor (cacheFileName) definován, pak se Image čte z něj.
        /// Pokud soubor neexistuje, nejprve se vytvoří.
        /// Umístění souboru (adresář) je dán property _ImageCacheDir, defaultně je to adresář (Sys:\Documents and Settings\All Users\Data aplikací\IconCache).
        /// Obsah obrázku definuje metoda getDataMethod.
        /// </summary>
        /// <param name="getDataMethod"></param>
        /// <param name="cacheFileName"></param>
        /// <returns></returns>
        private static System.Drawing.Image _ImageCreateFrom(_GetStringDelegate getDataMethod, string cacheFileName)
        {
            System.Drawing.Image image;
            if (cacheFileName == null)
            {
                using (System.IO.MemoryStream ms = new System.IO.MemoryStream(Convert.FromBase64String(getDataMethod())))
                {
                    image = System.Drawing.Image.FromStream(ms);
                }
                return image;
            }
            string fileName = System.IO.Path.Combine(_ImageCacheDir, cacheFileName);
            if (!System.IO.File.Exists(fileName))
                System.IO.File.WriteAllBytes(fileName, Convert.FromBase64String(getDataMethod()));
            if (System.IO.File.Exists(fileName))
                return Image.FromFile(fileName);
            return null;
        }
        /// <summary>
        /// Obsahuje jméno adresáře, který slouží jako Cache pro obrázky systému.
        /// </summary>
        private static string _ImageCacheDir
        {
            get
            {
                if (__ImageCacheDir == null)
                    __ImageCacheDir = Asol.Reporting.Support.Assistant.GetPath(Support.Assistant.PathType.ApplicationCache, @"Pics16");
                return __ImageCacheDir;
            }
        } private static string __ImageCacheDir;
        /// <summary>
        /// Předpis pro metody, které generují obsah souboru s daty
        /// </summary>
        /// <returns></returns>
        private delegate string _GetStringDelegate();
        /// <summary>
        /// Vrátí Icon z dat (string), která jsou předána na vstup v kódování Base64
        /// </summary>
        /// <param name="data">Vstupní data v kódování Base64</param>
        /// <returns>Icon vytvořená z dat</returns>
        public static System.Drawing.Icon ConvertStringToIcon(string data)
        {
            System.Drawing.Icon icon;
            using (System.IO.MemoryStream ms = new System.IO.MemoryStream(Convert.FromBase64String(data)))
            {
                icon = new System.Drawing.Icon(ms);
            }
            return icon;
        }
        /// <summary>
        /// Vrátí Cursor z dat (string), která jsou předána na vstup v kódování Base64
        /// </summary>
        /// <param name="data">Vstupní data v kódování Base64</param>
        /// <returns>Cursor vytvořený z dat</returns>
        public static System.Windows.Forms.Cursor ConvertStringToCursor(string data)
        {
            System.Windows.Forms.Cursor cursor;
            using (System.IO.MemoryStream ms = new System.IO.MemoryStream(Convert.FromBase64String(data)))
            {
                cursor = new System.Windows.Forms.Cursor(ms);
            }
            return cursor;
        }
        #endregion
    }
}
